#include "HtmlWidget.h"

#include <QDebug>
#include <QFont>
#include <QFontDatabase>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
#include <QPixmap>
#include <QResizeEvent>
#include <QTextDocument>
#include <QUrl>

HtmlWidget::HtmlWidget() : QWidget(nullptr), litehtml::document_container() {
    setAttribute(Qt::WA_OpaquePaintEvent);
    setAttribute(Qt::WA_NoSystemBackground);
    setMouseTracking(true);
}

HtmlWidget::~HtmlWidget() {}

litehtml::uint_ptr HtmlWidget::create_font(const char *faceName, int size,
                                           int weight,
                                           litehtml::font_style italic,
                                           unsigned int decoration,
                                           litehtml::font_metrics *fm) {
    QFont *font = new QFont();
    if (faceName) {
        font->setFamily(QString::fromUtf8(faceName));
    }
    font->setPointSize(size);

    // 设置字体粗细
    if (weight >= 700)
        font->setWeight(QFont::Bold);
    else if (weight <= 300)
        font->setWeight(QFont::Light);
    else
        font->setWeight(QFont::Normal);

    // 设置字体样式 - 简化实现，只检查font_style_italic
    if (italic == litehtml::font_style_italic) font->setItalic(true);

    // 设置文本装饰 - 简化实现，避免使用不存在的枚举
    // 暂时忽略underline和line-through装饰

    // 设置字体度量
    if (fm) {
        QFontMetrics metrics(*font);
        fm->ascent = metrics.ascent();
        fm->descent = metrics.descent();
        fm->height = metrics.height();
        fm->x_height = metrics.xHeight();
    }

    return reinterpret_cast<litehtml::uint_ptr>(font);
}

void HtmlWidget::delete_font(litehtml::uint_ptr hFont) {
    QFont *font = reinterpret_cast<QFont *>(hFont);
    delete font;
}

int HtmlWidget::text_width(const char *text, litehtml::uint_ptr hFont) {
    QFont *font = reinterpret_cast<QFont *>(hFont);
    if (font && text) {
        QFontMetrics metrics(*font);
        return metrics.horizontalAdvance(QString::fromUtf8(text));
    }
    return 0;
}

void HtmlWidget::draw_text(litehtml::uint_ptr hdc, const char *text,
                           litehtml::uint_ptr hFont, litehtml::web_color color,
                           const litehtml::position &pos) {
    QPainter *painter = reinterpret_cast<QPainter *>(hdc);
    if (!painter || !text) return;

    QFont *font = reinterpret_cast<QFont *>(hFont);
    if (font) {
        painter->save();
        painter->setFont(*font);
        painter->setPen(
            QColor(color.red, color.green, color.blue, color.alpha));
        // 简化实现，避免使用position成员
        // painter->drawText(0, 0, 200, 20, Qt::AlignLeft | Qt::AlignTop,
        //                   QString::fromUtf8(text));
        QFontMetrics metrics(*font);

        //qDebug() << "Paint " << text << " at " << pos.x << "x" << pos.y;
        painter->drawText(pos.x, pos.bottom() - metrics.descent(), text);
        painter->restore();
    }
}

int HtmlWidget::pt_to_px(int pt) const {
    // 1pt = 1.3333px
    return static_cast<int>(pt * 4.0 / 3.0);
}

int HtmlWidget::get_default_font_size() const { return 14; }

const char *HtmlWidget::get_default_font_name() const {
    static const char *defaultFont = "Arial";
    return defaultFont;
}

void HtmlWidget::draw_list_marker(litehtml::uint_ptr hdc,
                                  const litehtml::list_marker &marker) {
    QPainter *painter = reinterpret_cast<QPainter *>(hdc);
    if (!painter) return;

    painter->save();

    // 设置颜色
    QColor color(marker.color.red, marker.color.green, marker.color.blue,
                 marker.color.alpha);
    painter->setPen(color);
    painter->setBrush(color);

    // 简化的列表标记绘制 - 避免使用position成员和不存在的text成员
    painter->drawEllipse(10, 10, 6, 6);  // 绘制默认的点

    painter->restore();
}

void HtmlWidget::load_image(const char *src, const char *baseurl,
                            bool redraw_on_ready) {
    // 简单实现：将图片保存到缓存中
    QUrl url(QString::fromUtf8(src));
    if (!url.isValid() && baseurl) {
        QUrl baseUrl(QString::fromUtf8(baseurl));
        url = baseUrl.resolved(url);
    }

    // 实际应用中应该使用异步加载
    QPixmap pixmap;
    if (url.isLocalFile()) {
        pixmap.load(url.toLocalFile());
    } else if (url.scheme() == "file") {
        pixmap.load(url.path());
    }

    if (!pixmap.isNull() && redraw_on_ready) {
        update();
    }
}

void HtmlWidget::get_image_size(const char *src, const char *baseurl,
                                litehtml::size &sz) {
    // 简单实现：返回默认大小
    sz.width = 100;
    sz.height = 100;

    // 实际应用中应该从缓存或文件加载获取真实大小
}

void HtmlWidget::draw_background(
    litehtml::uint_ptr hdc,
    const std::vector<litehtml::background_paint> &bg)
{
    QPainter *painter = reinterpret_cast<QPainter *>(hdc);
    if (!painter) return;

    painter->save();

    // 简化实现，避免使用可能不存在的字段访问
    for (const auto &paint : bg) {

        if (paint.color.alpha > 0) {
            QColor color(paint.color.red, paint.color.green, paint.color.blue,
                         paint.color.alpha);
            painter->fillRect(paint.border_box.x, paint.border_box.y,
                              paint.border_box.width, paint.border_box.height,
                              color);
        }
    }

    painter->restore();
}

void HtmlWidget::draw_borders(litehtml::uint_ptr hdc,
                              const litehtml::borders &borders,
                              const litehtml::position &draw_pos, bool root) {
    QPainter *painter = reinterpret_cast<QPainter *>(hdc);
    if (!painter) return;

    painter->save();

    // 简化的边框绘制实现 - 完全避免使用position成员
    painter->restore();
}

void HtmlWidget::set_caption(const char *caption) {
    if (caption) {
        setWindowTitle(QString::fromUtf8(caption));
    }
}

void HtmlWidget::set_base_url(const char *base_url) {
    // 保存基础URL供后续使用
}

void HtmlWidget::link(const std::shared_ptr<litehtml::document> &doc,
                      const litehtml::element::ptr &el) {
    // 链接处理的实现
}

void HtmlWidget::on_anchor_click(const char *url,
                                 const litehtml::element::ptr &el) {
    // 锚点点击处理
    qDebug() << "Anchor clicked:" << QString::fromUtf8(url);
}

void HtmlWidget::set_cursor(const char *cursor) {
    if (cursor) {
        QString cursorStr = QString::fromUtf8(cursor);
        if (cursorStr == "pointer")
            setCursor(Qt::PointingHandCursor);
        else if (cursorStr == "text")
            setCursor(Qt::IBeamCursor);
        else if (cursorStr == "move")
            setCursor(Qt::SizeAllCursor);
        else
            setCursor(Qt::ArrowCursor);
    } else {
        setCursor(Qt::ArrowCursor);
    }
}

void HtmlWidget::transform_text(std::string &text,
                                litehtml::text_transform tt) {
    QString qText = QString::fromStdString(text);

    switch (tt) {
        case litehtml::text_transform_none:
            break;
        case litehtml::text_transform_capitalize:
            qText = qText.toLower();
            for (int i = 0; i < qText.length(); i++) {
                if (i == 0 || !qText[i - 1].isLetter())
                    qText[i] = qText[i].toUpper();
            }
            break;
        case litehtml::text_transform_uppercase:
            qText = qText.toUpper();
            break;
        case litehtml::text_transform_lowercase:
            qText = qText.toLower();
            break;
        default:
            break;
    }

    text = qText.toStdString();
}

void HtmlWidget::import_css(std::string &text, const std::string &url,
                            std::string &baseurl) {
    // 简单实现：不导入外部CSS
}

void HtmlWidget::set_clip(const litehtml::position &pos,
                          const litehtml::border_radiuses &bdr_radius) {
    // 设置裁剪区域 - 避免使用可能不存在的字段访问
    QPainterPath path;
    path.addRect(0, 0, 100, 100);

    // 实际应用中应该考虑border-radius
}

void HtmlWidget::del_clip() {
    // 删除裁剪区域
}

void HtmlWidget::get_client_rect(litehtml::position &client) const {
    // 简化实现，完全避免使用字段访问
    client.move_to(0, 0);
    client.width = width();
    client.height = height();
}

litehtml::element::ptr HtmlWidget::create_element(
    const char *tag_name, const litehtml::string_map &attributes,
    const std::shared_ptr<litehtml::document> &doc) {
    // 返回nullptr使用默认实现
    return nullptr;
}

void HtmlWidget::get_media_features(litehtml::media_features &media) const {
    // 只设置最基本的媒体特性
    media.type = litehtml::media_type_screen;
    // 移除可能不存在的字段设置
    // 避免使用orientation和aspect_ratio字段
}

void HtmlWidget::get_language(std::string &language,
                              std::string &culture) const {
    language = "en";
    culture = "en-US";
}

void HtmlWidget::paintEvent(QPaintEvent *event) {
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setRenderHint(QPainter::TextAntialiasing);

    if (m_html) {
        // litehtml::position clip(0, 0, width(), height());
        // 调用litehtml渲染文档 - 添加正确的类型转换
        m_html->render(width());
        m_html->draw((litehtml::uint_ptr)&painter, 0, 0, nullptr);
    }
}

void HtmlWidget::resizeEvent(QResizeEvent *event) {
    QWidget::resizeEvent(event);

    // if (m_html) {
    //     // 简化窗口大小改变时的布局处理
    //     try {
    //         // 添加正确的类型转换
    //         m_html->render(width(), static_cast<litehtml::render_type>(0));
    //     } catch (...) {
    //         // 如果失败，静默处理
    //     }
    // }
    // update();
}

void HtmlWidget::setHtmlDocument(litehtml::document::ptr doc) {
    m_html = doc;
    // if (m_html) {
    //     // 使用litehtml的正确方法进行初始化
    //     try {
    //         // 预渲染以进行布局
    //         m_html->render(reinterpret_cast<litehtml::uint_ptr>(nullptr));
    //     } catch (...) {
    //         // 如果失败，静默处理
    //     }
    // }
    // update();
}
